/**
* @author TDSoft
*
* La clase GestorUsuario se encarga de gestionar la persistencia de los datos relativos a Usuarios
*
* @see Usuario
*/
package edu.uoc.tds.pec4.server.bbdd;

import edu.uoc.tds.pec4.common.RemotoInterface;
import edu.uoc.tds.pec4.model.Usuario;
import edu.uoc.tds.pec4.model.Administrador;
import edu.uoc.tds.pec4.model.Estudiante;
import edu.uoc.tds.pec4.model.ResponsablePrueba;
import edu.uoc.tds.pec4.model.TipoUsuario;
import edu.uoc.tds.pec4.model.Universidad;
import edu.uoc.tds.pec4.i18n.GestorIdiomas;
import edu.uoc.tds.pec4.exception.UsuarioNoExisteException;
import java.rmi.RemoteException;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.util.Date;
import java.util.ArrayList;
import java.util.List;

public class GestorUsuario {
    
    //Atributo para gestionar el servicio de acceso remoto
    private RemotoInterface remoto;
    private GestorUniversidad gestorUniversidad;

     /**
     * Constructor con parámetros de la clase GestorUsuario.
     * Crea una instancia de GestorUsuario.
     * {pre: se recibe como parametro la instancia del servidor remoto}
     * {post: asigna el servidor remoto a la instancia de GestorUsuario que se va utilizar en toda la clase}
     */
    public GestorUsuario(RemotoInterface remoto){
        this.remoto = remoto;
        this.gestorUniversidad = new GestorUniversidad(remoto);
    }

    /**
     * Método para obtener una instancia de Usuario a partir de su login y clave de conexión
     * {pre: un login y clave de conexión}
     * {post: una instancia de Usuario que referencia, según el tipo de usuario a un Administrador,Responsable de Prueba o Estudiante}
     * @param login_usuario hace referencia al login del usuario.
     * @param clave hace referencia a la clave del usuario. 
     */
    public Usuario validarUsuario(String login_usuario, String clave) throws RemoteException{
        
        Usuario usuario = new Usuario();
        String sqlString = "";
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            //Establecemos la sentencia para obtener los datos del usuario
            sqlString = "SELECT id_usuario,id_tipo_usuario,"
                            + "id_universidad,usuario,clave,nombre,"
                            + "apellido_primero,apellido_segundo,"
                            + "documento,fecha_alta,fecha_baja"
                            + " FROM " + this.remoto.getSchema() + ".usuario where usuario = ? and clave = ?";
            preparedStatement = this.remoto.getConexion().prepareStatement(sqlString);
            preparedStatement.setString(1,login_usuario);
            preparedStatement.setString(2,clave);
            resultSet = preparedStatement.executeQuery();
            
            if(resultSet.next()){
                usuario = getUsuarioFromResultSet(resultSet);
            }
        }
         /** Capturamos el error en el acceso a la BBDD */
        catch (SQLException exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.gestorbbdd.bbdd"));
        }
        /** Capturamos el error remoto */
        catch (RemoteException exc) {
            throw new RemoteException(exc.getMessage());
        }
        /** Capturamos excepción de carácter general*/
        catch (Exception exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.general"));
        }
        /** En todo caso ejecutamos el siguiente código*/
        finally {
            try {
                resultSet.close();
                preparedStatement.close();
            }
            /** Capturamos excepción de carácter general*/
            catch (Exception exc) {
                //Excepción inesperada
                throw new RemoteException(GestorIdiomas.getMessage("error.general"));
            }
        }
        return usuario;
    }
    
    /**
     * Método para obtener una instancia de Usuario a partir de identificador
     * {pre: identificador de un usuario}
     * {post: una instancia de Usuario que referencia, según el tipo de usuario a un Administrador,Responsable de Prueba o Estudiante}
     * @param id_usuario hace referencia al identificador del usuario.
     */
    public Usuario getUsuario(int id_usuario) throws RemoteException{
        
        Usuario usuario = new Usuario();
        //Establecemos la sentencia para obtener los datos del usuario
        String sqlString = "SELECT id_usuario,"
                            + "id_tipo_usuario,"
                            + "id_universidad,"
                            + "usuario,"
                            + "clave,"
                            + "nombre,"
                            + "apellido_primero,"
                            + "apellido_segundo,"
                            + "documento,"
                            + "fecha_alta,"
                            + "fecha_baja "
                            + "FROM " + this.remoto.getSchema() + ".usuario "
                            + "WHERE id_usuario = ?";

        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            preparedStatement = this.remoto.getConexion().prepareStatement(sqlString);
            preparedStatement.setInt(1,id_usuario);
            resultSet = preparedStatement.executeQuery();
            if(resultSet.next()){
                usuario = getUsuarioFromResultSet(resultSet);
            }else{
                //Lanzamos excepción en caso de que no exista un usuario para el identificador
                throw new UsuarioNoExisteException(GestorIdiomas.getMessage("error.idusuario.no.existe"));
            }
        }
        /** Capturamos el error de Usuario no validado porque no se encuentra en el sistema */
        catch(UsuarioNoExisteException exc){
            throw new RemoteException(exc.getMessage());
        }
        /** Capturamos el error remoto */
        catch (RemoteException exc) {
            throw new RemoteException(exc.getMessage());
        }
        /** Capturamos el error en el acceso a la BBDD */
        catch (SQLException exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.gestorbbdd.bbdd"));
        }
        /** Capturamos excepción de carácter general*/
        catch (Exception exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.general"));
        }
        /** En todo caso ejecutamos el siguiente código*/
        finally {
            try {
		resultSet.close();
                preparedStatement.close();
            }
            /** Capturamos excepción de carácter general*/
            catch (Exception exc) {
                //Excepción inesperada
                throw new RemoteException(GestorIdiomas.getMessage("error.general"));
            }
        }

        return usuario;
    }
    
    /**
     * Método para dar de alta en el sistema y crear la instancia de Usuario con el identificador generado por el sistema
     * {pre: id_tipo_usuario es un entero distinto de cero
     *      login es una cadena que no puede ser vacía
     *      clave es una cadena que no puede ser vacía
     *      documento es una cadena que no puede ser vacía
     *      nombre es una cadena que no puede ser vacía
     *      apellido_primero es una cadena que no puede ser vacía
     *      apellido_segundo es una cadena que puede ser vacía 
     *      id_universidad es un entero, distinto de cero cuando el usuario es de tipo estudiante
     *      fecha_alta es una fecha que no puede ser vacía}
     * {post: una instancia de Usuario que referencia, según el tipo de usuario a un Administrador,Responsable de Prueba o Estudiante}
     * @param id_tipo_usuario representa el identificador del tipo de usuario
     * @param login representa el nombre de conexión a la aplicación para el usuario
     * @param clave representa la clave de conexión a la aplicación para el usuario
     * @param documento representa el documento de identificación del usuario
     * @param nombre representa el nombre del usuario
     * @param apellido_primero representa el apellido primero del usuario
     * @param apellido_segundo representa el apellido segundo del usuario
     * @param id_universidad representa el identificador de la universidad a la que pertenece el usuario
     * @param fecha_alta representa la fecha de alta del usuario en el sistema
     */
    public Usuario altaUsuario(int id_tipo_usuario, String login, String clave, String documento,
                                String nombre, String apellidoPrimero, String apellidoSegundo, 
                                int id_universidad, Date fecha_alta) throws RemoteException{
        String sqlString = "";
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        Usuario usuario = new Usuario();
        String apellido2 = "";
        
        try {
            java.sql.Date sqlDate = new java.sql.Date(fecha_alta.getTime());
            if (apellidoSegundo.length()==0){
                apellido2 = null;
            }else{
                apellido2= apellidoSegundo;
            }
                
            if(id_tipo_usuario==TipoUsuario.ESTUDIANTE.getIdTipoUsuario()){
                //Establecemos la sentencia para dar de alta al estudiante
                sqlString = "INSERT INTO " + this.remoto.getSchema() + ".usuario "
                        + "(id_tipo_usuario,"
                        + "id_universidad,"
                        + "usuario,"
                        + "clave,"
                        + "nombre,"
                        + "apellido_primero,"
                        + "apellido_segundo,"
                        + "documento,"
                        + "fecha_alta)"
                        + " VALUES (?,?,?,?,?,?,?,?,?)"
                        + " RETURNING usuario.*;";
                preparedStatement = this.remoto.getConexion().prepareStatement(sqlString);
                preparedStatement.setInt(1,id_tipo_usuario);
                preparedStatement.setInt(2,id_universidad);
                preparedStatement.setString(3,login);
                preparedStatement.setString(4,clave);
                preparedStatement.setString(5,nombre);
                preparedStatement.setString(6,apellidoPrimero);
                preparedStatement.setString(7,apellido2);
                preparedStatement.setString(8,documento); 
                preparedStatement.setDate(9,sqlDate); 
            }
            else{
                //Establecemos la sentencia para dar de alta al usuario que no es estudiante
                sqlString = "INSERT INTO " + this.remoto.getSchema() + ".usuario "
                        + "(id_tipo_usuario,"
                        + "usuario,"
                        + "clave,"
                        + "nombre,"
                        + "apellido_primero,"
                        + "apellido_segundo,"
                        + "documento,"
                        + "fecha_alta)"
                        + " VALUES (?,?,?,?,?,?,?,?)"
                        + " RETURNING usuario.*;";
                preparedStatement = this.remoto.getConexion().prepareStatement(sqlString);
                preparedStatement.setInt(1,id_tipo_usuario);
                preparedStatement.setString(2,login);
                preparedStatement.setString(3,clave);
                preparedStatement.setString(4,nombre);
                preparedStatement.setString(5,apellidoPrimero);
                preparedStatement.setString(6,apellido2);
                preparedStatement.setString(7,documento);
                preparedStatement.setDate(8,sqlDate);
            }
            
            resultSet = preparedStatement.executeQuery();
            if(resultSet.next()){
                usuario = getUsuarioFromResultSet(resultSet);
            }
        }
        /** Capturamos el error remoto */
        catch (RemoteException exc) {
            throw new RemoteException(exc.getMessage());
        }
        /** Capturamos el error en el acceso a la BBDD */
        catch (SQLException exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.gestorbbdd.bbdd"));
        }
        /** Capturamos excepción de carácter general*/
        catch (Exception exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.general"));
        }
        /** En todo caso ejecutamos el siguiente código*/
        finally {
            try {
		resultSet.close();
                preparedStatement.close();
            }
            /** Capturamos excepción de carácter general*/
            catch (Exception exc) {
                //Excepción inesperada
                throw new RemoteException(GestorIdiomas.getMessage("error.general"));
            }
        }

        return usuario;
    }
    
    /**
     * Método para dar de baja un usuario a partir de su identificador
     * {pre: usuario existente en el sistema}
     * {post: el usuario se da de baja lógica en el sistema y se le asigna la fecha de baja}
     * @param id_usuario hace referencia al identificador del usuario.
     * @param fecha_baja hace referencia a la fecha de baja.
     */
    public void bajaUsuario(int id_usuario, Date fecha_baja) throws RemoteException{
        
        //Establecemos la sentencia para dar de baja al usuario
        String sqlString = "UPDATE " + this.remoto.getSchema() + ".usuario "
                        + " SET fecha_baja = ?"
                        + " WHERE id_usuario = ?;";
        PreparedStatement preparedStatement = null;
        
        try {
            java.sql.Date sqlDate = new java.sql.Date(fecha_baja.getTime());
            preparedStatement = this.remoto.getConexion().prepareStatement(sqlString);
            preparedStatement.setDate(1,sqlDate);
            preparedStatement.setInt(2,id_usuario);
            preparedStatement.executeUpdate();
        }
        /** Capturamos el error en el acceso a la BBDD */
        catch (SQLException exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.gestorbbdd.bbdd"));
        }
        /** Capturamos excepción de carácter general*/
        catch (Exception exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.general"));
        }
        /** En todo caso ejecutamos el siguiente código*/
        finally {
            try {
		preparedStatement.close();
            }
            /** Capturamos excepción de carácter general*/
            catch (Exception exc) {
                //Excepción inesperada
                throw new RemoteException(GestorIdiomas.getMessage("error.general"));
            }
        }
    }
    
    /**
     * Método para obtener una lista de Usuarios a partir de unos filtros de búsqueda determinados
     * {pre: los usuarios existen en el sistema}
     * {post: una lista de Usuarios que referencian, según el tipo de usuario a un Administrador,Responsable de Prueba o Estudiante}
     * @param id_tipo_usuario hace referencia al tipo de usuario.
     * @param id_usuario hace referencia al identificador del usuario.
     * @param documento hace referencia al documento del usuario.
     * @param nombre hace referencia al nombre del usuario.
     * @param apellido_primero hace referencia al apellido primero del usuario.
     * @param fecha_alta hace referencia a la fecha en la que se dio de alta al usuario.
     * @param operador_fecha_alta hace referencia al operador por el que se desea filtrar la fecha de alta del usuario.
     * @param activos hace referencia a si se filtra por usuarios que estén no estén dados de baja o sí.
     * @param fecha_baja hace referencia a la fecha en la que se dio de baja al usuario.
     * @param operador_fecha_baja hace referencia al operador por el que se desea filtrar la fecha de baja del usuario.
     * @param id_universidad hace referencia al identificador de la universidad del usuario de tipo estudiante.
     */
    public List<Usuario> getListaUsuarios(int id_tipo_usuario,int id_usuario, String documento, 
                                          String nombre, String apellido_primero, Date fecha_alta,
                                          String operador_fecha_alta, boolean activos,
                                          Date fecha_baja, String operador_fecha_baja,
                                          int id_universidad) throws RemoteException{
        
        List<Usuario> listaUsuarios = new ArrayList<Usuario>();
        StringBuffer sqlString = new StringBuffer();
        //Establecemos la sentencia para buscar los usuarios en función de los filtros recibidos
	sqlString.append("SELECT id_usuario,id_tipo_usuario,"
                            + "id_universidad,usuario,clave,nombre,"
                            + "apellido_primero,apellido_segundo,"
                            + "documento,fecha_alta,fecha_baja"
                            + " FROM " + this.remoto.getSchema() + ".usuario " );
        //Control del número de parámetros que usaremos en la sentencia
        int param = 0;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        java.sql.Date sqlDate = null;

        try {
            //Si nos pasan el parámetro id_usuario lo añadimos como filtro
            if (id_usuario != 0){
                sqlString.append(" WHERE id_usuario = ? ");
                param++;
            }
            //Si nos pasan el parámetro id_tipo_usuario lo añadimos como filtro
            if (id_tipo_usuario != 0){
                if (param > 0) sqlString.append(" AND id_tipo_usuario = ? ");
                else sqlString.append(" WHERE id_tipo_usuario = ? ");
                param++;
            }
            //Si nos pasan el parámetro documento lo añadimos como filtro
            if (documento.length() > 0){
                if (param > 0) sqlString.append(" AND documento = ? ");
                else sqlString.append(" WHERE documento = ? ");
                param++;
            }
            //Si nos pasan el nombre lo añadimos como filtro
            if (nombre.length() > 0){
                if (param > 0) sqlString.append(" AND nombre = ? ");
                else sqlString.append(" WHERE nombre = ? ");
                param++;
            }
            //Si nos pasan apellido_primero lo añadimos como filtro
            if (apellido_primero.length() > 0){
                if (param > 0) sqlString.append(" AND apellido_primero = ? ");
                else sqlString.append(" WHERE apellido_primero = ? ");
                param++;
            }
            //Por fecha de alta pueden buscar tanto por activos como si no.
            //Si nos pasan la fecha de alta hay que tener en cuenta el operador por el que quieren buscar
            if (fecha_alta != null){
                if (param > 0) sqlString.append(" AND fecha_alta " + operador_fecha_alta + " ? ");
                else sqlString.append(" WHERE fecha_alta " + operador_fecha_alta + " ? ");
                param++;
            }
            if (activos){
                //Esto implica que sólo quieren usuarios que no estén de baja
                if (param > 0) sqlString.append(" AND fecha_baja is null ");
                else sqlString.append(" WHERE fecha_baja is null ");
                param++;
            }else{
                //Puede ser que sino especifican fecha de baja, tengan cualquiere fecha de baja, o sea, no nula
                if (param > 0) sqlString.append(" AND fecha_baja is not null ");
                else sqlString.append(" WHERE fecha_baja is not null ");
                param++;
                //Si además nos filtran por fecha de baja, buscamos por el operador pasado y fecha de baja
                if (fecha_baja != null){
                    if (param > 0) sqlString.append(" AND fecha_baja " + operador_fecha_baja + " ? ");
                    else sqlString.append(" WHERE fecha_baja " + operador_fecha_baja + " ? ");
                    param++;
                }
            }
            //Si nos pasan id_universidad lo añadimos como filtro
            if (id_universidad != 0){
                if (param > 0) sqlString.append(" AND id_universidad = ? ");
                else sqlString.append(" WHERE id_universidad = ? ");
                param++;
            }
            
            preparedStatement = this.remoto.getConexion().prepareStatement(sqlString.toString());
            
            //Asignamos los valores de cada parámetro
            param = 1;
            if (id_usuario != 0){
                preparedStatement.setInt(param,id_usuario);
                param++;
            }
            if (id_tipo_usuario != 0){
                preparedStatement.setInt(param,id_tipo_usuario);
                param++;
            }
            if (documento.length() > 0){
                preparedStatement.setString(param,documento);
                param++;
            }
            if (nombre.length() > 0){
                preparedStatement.setString(param,nombre);
                param++;
            }
            if (apellido_primero.length() > 0){
                preparedStatement.setString(param,apellido_primero);
                param++;
            }
            if (fecha_alta != null){
                sqlDate = new java.sql.Date(fecha_alta.getTime());
                preparedStatement.setDate(param,sqlDate);
                param++;
            }
            if (!activos){
                if (fecha_baja != null){
                    sqlDate = new java.sql.Date(fecha_baja.getTime());
                    preparedStatement.setDate(param,sqlDate);
                    param++;
                }
            }
            if (id_universidad != 0){
                preparedStatement.setInt(param,id_universidad);
                param++;
            }
            
            resultSet = preparedStatement.executeQuery();
            
            while (resultSet.next()) {
                listaUsuarios.add(getUsuarioFromResultSet(resultSet));           
            }
        }
         /** Capturamos el error remoto */
        catch (RemoteException exc) {
            throw new RemoteException(exc.getMessage());
        }
        /** Capturamos el error en el acceso a la BBDD */
        catch (SQLException exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.gestorbbdd.bbdd"));
        }
        /** Capturamos excepción de carácter general*/
        catch (Exception exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.general"));
        }
        /** En todo caso ejecutamos el siguiente código*/
        finally {
            try {
		resultSet.close();
                preparedStatement.close();
            }
            /** Capturamos excepción de carácter general*/
            catch (Exception exc) {
                //Excepción inesperada
                throw new RemoteException(GestorIdiomas.getMessage("error.general"));
            }
        }
        
        return listaUsuarios;
    }
    
    /**
     * Método para comprobar si existe el login para algún otro usuario en el sistema
     * {pre: Administrador intenta dar de alta usuario}
     * {post: devuelve verdadero si ya existe el login. False en caso contrario.}
     * @param login_usuario hace referencia al login para el usuario que está dando de alta el Administrador.
     */
    public boolean existeLogin(String login_usuario) throws RemoteException{
        
        boolean existe = false;
        String sqlString = "";
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            //Establecemos la sentencia para chequear si existe el login
            sqlString = "SELECT COUNT(*) "
                        + " FROM " + this.remoto.getSchema() + ".usuario where usuario = ?";
            preparedStatement = this.remoto.getConexion().prepareStatement(sqlString);
            preparedStatement.setString(1,login_usuario);
            resultSet = preparedStatement.executeQuery();
            if(resultSet.next()){
                if (resultSet.getInt("COUNT")>0){
                    existe = true;
                }
            }
        }
         /** Capturamos el error en el acceso a la BBDD */
        catch (SQLException exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.gestorbbdd.bbdd"));
        }
        /** Capturamos excepción de carácter general*/
        catch (Exception exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.general"));
        }
        /** En todo caso ejecutamos el siguiente código*/
        finally {
            try {
                resultSet.close();
                preparedStatement.close();
            }
            /** Capturamos excepción de carácter general*/
            catch (Exception exc) {
                //Excepción inesperada
                throw new RemoteException(GestorIdiomas.getMessage("error.general"));
            }
        }
        return existe;
    }
    
    /**
     * Método para comprobar si existe el documento para algún otro usuario en el sistema
     * {pre: Administrador intenta dar de alta usuario}
     * {post: devuelve verdadero si ya existe el documento. False en caso contrario.}
     * @param documento hace referencia al documento para el usuario que está dando de alta el Administrador.
     */
    public boolean existeDocumento(String documento) throws RemoteException{
        boolean existe = false;
        String sqlString = "";
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            //Establecemos la sentencia para chequear si existe el documento
            sqlString = "SELECT count(*) "
                        + " FROM " + this.remoto.getSchema() + ".usuario where documento = ?";
            preparedStatement = this.remoto.getConexion().prepareStatement(sqlString);
            preparedStatement.setString(1,documento);
            resultSet = preparedStatement.executeQuery();
            if(resultSet.next()){
                if (resultSet.getInt("count")>0){
                    existe = true;
                }
            }
        }
         /** Capturamos el error en el acceso a la BBDD */
        catch (SQLException exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.gestorbbdd.bbdd"));
        }
        /** Capturamos excepción de carácter general*/
        catch (Exception exc) {
            throw new RemoteException(GestorIdiomas.getMessage("error.general"));
        }
        /** En todo caso ejecutamos el siguiente código*/
        finally {
            try {
                resultSet.close();
                preparedStatement.close();
            }
            /** Capturamos excepción de carácter general*/
            catch (Exception exc) {
                //Excepción inesperada
                throw new RemoteException(GestorIdiomas.getMessage("error.general"));
            }
        }
        return existe;
    }
    
    /**
     * Método para crear la instancia de un usuario en función de los datos recuperados de la base de datos
     * {pre: Se ha recuperado la información del usuario de bbdd}
     * {post: devuelve la instancia usuario con los datos recuperados de la base de datos}
     * @param resultSet hace referencia al objeto Resulset.
     */
    private Usuario getUsuarioFromResultSet(ResultSet resultSet) throws SQLException, RemoteException{
        Usuario usuario =  new Usuario();
        if (resultSet.getInt("id_tipo_usuario") == TipoUsuario.ADMINISTRADOR.getIdTipoUsuario()){
            //Si el usuario es de tipo administrador se crea la instancia que hace referencia a Administrador
            usuario = new Administrador(resultSet.getInt("id_usuario"),
                    resultSet.getString("usuario"),resultSet.getString("clave"),
                    resultSet.getString("nombre"),resultSet.getString("apellido_primero"),
                    resultSet.getString("apellido_segundo"),resultSet.getString("documento"),
                    resultSet.getDate("fecha_alta"),resultSet.getDate("fecha_baja"));
        }else if (resultSet.getInt("id_tipo_usuario") == TipoUsuario.RESPONSABLE_PRUEBA.getIdTipoUsuario()){
            //Si el usuario es de tipo responsable de prueba se crea la instancia que hace referencia a ResponsablePrueba
            usuario = new ResponsablePrueba(resultSet.getInt("id_usuario"),
                    resultSet.getString("usuario"),resultSet.getString("clave"),
                    resultSet.getString("nombre"),resultSet.getString("apellido_primero"),
                    resultSet.getString("apellido_segundo"),resultSet.getString("documento"),
                    resultSet.getDate("fecha_alta"),resultSet.getDate("fecha_baja"));
        }else if (resultSet.getInt("id_tipo_usuario") == TipoUsuario.ESTUDIANTE.getIdTipoUsuario()){
            //Como es un usuario de tipo estudiante, recuperamos la información de la universidad
            //a partir del id_universidad
            Universidad universidad = this.remoto.getUniversidad(resultSet.getInt("id_universidad"));
            //Si el usuario es de tipo estudiante se crea la instancia que hace referencia a Estudiante
            usuario = new Estudiante(resultSet.getInt("id_usuario"),
                    resultSet.getString("usuario"),resultSet.getString("clave"),
                    resultSet.getString("nombre"),resultSet.getString("apellido_primero"),
                    resultSet.getString("apellido_segundo"),resultSet.getString("documento"),
                    resultSet.getDate("fecha_alta"),resultSet.getDate("fecha_baja"),
                    universidad);
        }
        return usuario;
    }
            
}
